{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save padded image\n",
    "Given an image path (`im_pth`), the code below will extract its file name (`file_name`) and generate the following images in the `transformed_images` directory:\n",
    "* unpadded original image: `{file_name}_no_pad.png`\n",
    "* padded image to fit into square dimensions: `{file_name}_pad.png`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from PIL import Image\n",
    "\n",
    "img_size = 2048\n",
    "# im_pth = '/home/aisinai/data/mimic/valid/p10296197/s03/view1_frontal.jpg'  # change to your image path\n",
    "im_pth = '/home/aisinai/data/mimic/valid/p10296197/s03/view2_lateral.jpg'  # change to your image path\n",
    "base = os.path.basename(im_pth)\n",
    "file_name = os.path.splitext(base)[0]\n",
    "\n",
    "os.makedirs('transformed_images', exist_ok=True)\n",
    "\n",
    "im = Image.open(im_pth)\n",
    "im.save(f'transformed_images/{file_name}_no_pad.png')\n",
    "\n",
    "old_size = im.size  # old_size[0] is in (width, height) format\n",
    "ratio = float(img_size) / max(old_size)\n",
    "new_size = tuple([int(x * ratio) for x in old_size])\n",
    "im = im.resize(new_size, Image.ANTIALIAS)\n",
    "\n",
    "# create a new image for padding and paste the resized on it\n",
    "new_im = Image.new(\"RGB\", (img_size, img_size))\n",
    "new_im.paste(im, ((img_size - new_size[0]) // 2,\n",
    "                  (img_size - new_size[1]) // 2))\n",
    "new_im.save(f'transformed_images/{file_name}_pad.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save reconstructed images\n",
    "There are 4 models, identified by their train runs. First three models have encoder output depth of 64.\n",
    "* 0: Model A. 2 convolutions in the first / bottom layer | 1 convolution  in the second / top layer\n",
    "* 1: Model B. 3 convolutions in the first / bottom layer | 2 convolutions in the second / top layer\n",
    "* 3: Model C. 4 convolutions in the first / bottom layer | 2 convolutions in the second / top layer\n",
    "\n",
    "Last model, Model D, have encoder output depth of 1.\n",
    "* embed1: Model D. 2 convolutions in the first / bottom layer | 1 convolution in the second / top layer\n",
    "\n",
    "It takes as the input the padded image in the `transformed_images` directory from the above code block and generate the following images in the `transformed_images` directory: \n",
    "* `{file_name}_original.png`\n",
    "* Output from Model A: `{file_name}_recon_A.png`\n",
    "* Output from Model B: `{file_name}_recon_B.png`\n",
    "* Output from Model C: `{file_name}_recon_C.png`\n",
    "* Output from Model D: `{file_name}_recon_D.png`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.autograd import Variable\n",
    "from networks import VQVAE\n",
    "from PIL import Image\n",
    "from torchvision import transforms\n",
    "from torchvision.utils import save_image\n",
    "from utilities import rgb2gray\n",
    "\n",
    "cuda = True if torch.cuda.is_available() else False\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "\n",
    "mean = [0.485, 0.456, 0.406]\n",
    "std = [0.229, 0.224, 0.225]\n",
    "normalization = transforms.Normalize(mean=mean, std=std)\n",
    "transform_array = [transforms.Resize(img_size), transforms.CenterCrop(img_size), transforms.ToTensor(), normalization]\n",
    "transform = transforms.Compose(transform_array)\n",
    "\n",
    "image = torch.zeros((1, 3, img_size, img_size))  # img_size from above\n",
    "image[0, :] = transform(Image.open(f'transformed_images/{file_name}_pad.png'))  # file_name from above\n",
    "\n",
    "mean = torch.FloatTensor([0.485, 0.456, 0.406]).reshape(3, 1, 1).type(Tensor)\n",
    "std = torch.FloatTensor([0.229, 0.224, 0.225]).reshape(3, 1, 1).type(Tensor)\n",
    "\n",
    "for model_name in ['A', 'B', 'C', 'D']:\n",
    "    if model_name == 'A':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model A\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/0/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=4, second_stride=2).cuda() if cuda else VQVAE()\n",
    "    elif model_name == 'B':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model B\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/1/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=8, second_stride=4).cuda() if cuda else VQVAE()\n",
    "    elif model_name == 'C':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model C\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/3/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=16, second_stride=4).cuda() if cuda else VQVAE()\n",
    "    elif model_name == 'D':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model D\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/embed1/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=4, second_stride=2, embed_dim=1).cuda() if cuda else VQVAE()\n",
    "\n",
    "    model.load_state_dict(torch.load(model_dir))\n",
    "    n_gpu = torch.cuda.device_count()\n",
    "    if n_gpu > 1:\n",
    "        device_ids = list(range(n_gpu))\n",
    "        model = nn.DataParallel(model, device_ids=device_ids)\n",
    "    model.eval()\n",
    "    original_img = Variable(image.type(Tensor))\n",
    "\n",
    "    with torch.no_grad():\n",
    "        out, _ = model(original_img)\n",
    "        decoded_img, _ = model(original_img)\n",
    "        quant_t, quant_b, _, id_t, id_b = model.encode(original_img)\n",
    "        upsample_t = model.upsample_t(quant_t)\n",
    "        quant = torch.cat([upsample_t, quant_b], 1)\n",
    "\n",
    "    original_img = original_img * std + mean\n",
    "    out = out * std + mean\n",
    "    save_image(original_img[0,:].data,\n",
    "               f'transformed_images/{file_name}_original.png', \n",
    "               nrow=1, normalize=True, range=(0,1))\n",
    "    save_image(out[0,:].data,\n",
    "               f'transformed_images/{file_name}_recon_{model_name}.png',\n",
    "               nrow=1, normalize=True, range=(0,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compute PSNR\n",
    "Take two directories, one containing the original images and the other the reconstructed images, and compute PSNR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average PSNR value for model A is 45.39284165046035 dB\n",
      "Average PSNR value for model B is 44.05189311629433 dB\n",
      "Average PSNR value for model C is 41.590470862564146 dB\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "from math import log10, sqrt\n",
    "\n",
    "orig_dir = '/home/aisinai/work/VQ-VAE2-Images/1024/frontal/original'\n",
    "recon_dir = '/home/aisinai/work/VQ-VAE2-Images/1024/frontal'\n",
    "\n",
    "def PSNR(original, compressed):\n",
    "    mse = np.mean((original - compressed) ** 2)\n",
    "    if(mse == 0):  # MSE is zero means no noise is present in the signal.\n",
    "                   # Therefore PSNR have no importance.\n",
    "        return 100\n",
    "    max_pixel = 255.0\n",
    "    psnr = 20 * log10(max_pixel / sqrt(mse))\n",
    "    return psnr\n",
    "\n",
    "PSNRs = []\n",
    "for model in ['A', 'B', 'C']:\n",
    "    for image in os.listdir(orig_dir):\n",
    "        original = np.asarray(Image.open(f'{orig_dir}/{image}').convert('RGB'))\n",
    "        recon = np.asarray(Image.open(f'{recon_dir}/{model}/{image}').convert('RGB'))\n",
    "        PSNRs.append(PSNR(original, recon))\n",
    "    print(f'Average PSNR value for model {model} is {np.average(PSNRs)} dB')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save VQ-VAE-2 Models as ONNX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model A: saved to model_A.onnx\n",
      "Model B: saved to model_B.onnx\n",
      "Model C: saved to model_C.onnx\n",
      "Model D: saved to model_D.onnx\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from networks import VQVAE\n",
    "\n",
    "cuda = True if torch.cuda.is_available() else False\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "\n",
    "img_size = 1024\n",
    "batch_size = 1\n",
    "num_channel = 3  # 3 for RGB\n",
    "dummy_image = torch.randn(batch_size, num_channel, img_size, img_size, requires_grad=True)\n",
    "\n",
    "for model_name in ['A', 'B', 'C', 'D']:\n",
    "    if model_name == 'A':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model A\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/0/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=4, second_stride=2)\n",
    "    elif model_name == 'B':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model B\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/1/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=8, second_stride=4)\n",
    "    elif model_name == 'C':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model C\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/3/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=16, second_stride=4)\n",
    "    elif model_name == 'D':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for model D\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200422/vq_vae/CheXpert/embed1/checkpoint/vqvae_040.pt'\n",
    "        model = VQVAE(first_stride=4, second_stride=2, embed_dim=1)\n",
    "\n",
    "    model.load_state_dict(torch.load(model_dir))\n",
    "    model.eval()\n",
    "    out = model(dummy_image)\n",
    "    torch.onnx.export(model, dummy_image, f'model_{model_name}.onnx')\n",
    "    print(f'Model {model_name}: saved to model_{model_name}.onnx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save DenseNet-121 Models as ONNX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model orig: saved to model_orig.onnx\n",
      "Model recon: saved to model_recon.onnx\n",
      "Model latent: saved to model_latent.onnx\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from networks import Densenet121\n",
    "\n",
    "cuda = True if torch.cuda.is_available() else False\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "\n",
    "img_size = 256\n",
    "batch_size = 1\n",
    "\n",
    "dummy_input = torch.randn(batch_size, num_channel, img_size, img_size, requires_grad=True)\n",
    "n_classes = 14\n",
    "\n",
    "for model_name in ['orig', 'recon', 'latent']:\n",
    "    if model_name == 'orig':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for original image inputs\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200424/densenet121/orig/best_densenet_model.pt'\n",
    "        model = Densenet121(n_classes=n_classes, input_type=model_name)\n",
    "        model.model.load_state_dict(torch.load(model_dir))\n",
    "        num_channel = 3  # 3 for RGB\n",
    "        dummy_input = torch.randn(batch_size, num_channel, img_size, img_size, requires_grad=True)\n",
    "    elif model_name == 'recon':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for reconstructed image inputs\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200424/densenet121/recon/best_densenet_model.pt'\n",
    "        model = Densenet121(n_classes=n_classes, input_type=model_name)\n",
    "        model.model.load_state_dict(torch.load(model_dir))\n",
    "        num_channel = 3  # 3 for RGB\n",
    "        dummy_input = torch.randn(batch_size, num_channel, img_size, img_size, requires_grad=True)\n",
    "    elif model_name == 'latent':\n",
    "        # model_dir = path to {saved_model}.pt checkpoint file for latent vector inputs\n",
    "        model_dir = '/home/aisinai/work/VQ-VAE2/20200424/densenet121/latent/best_densenet_model.pt'\n",
    "        model = Densenet121(n_classes=n_classes, input_type=model_name)\n",
    "        num_channel = 2  # 2 for 2 latent vectors concatenated\n",
    "        dummy_input = torch.randn(batch_size, num_channel, img_size, img_size, requires_grad=True)\n",
    "        model.load_state_dict(torch.load(model_dir))\n",
    "\n",
    "    model.eval()\n",
    "    out = model(dummy_input)\n",
    "    torch.onnx.export(model, dummy_input, f'densenet_{model_name}.onnx')\n",
    "    print(f'Model {model_name}: saved to model_{model_name}.onnx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compute Number of FLOPs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: module _DenseLayer is treated as a zero-op.\n",
      "Warning: module _DenseBlock is treated as a zero-op.\n",
      "Warning: module _Transition is treated as a zero-op.\n",
      "Warning: module Sigmoid is treated as a zero-op.\n",
      "Warning: module DenseNet is treated as a zero-op.\n",
      "Warning: module Densenet121 is treated as a zero-op.\n",
      "Densenet121(\n",
      "  6.968 M, 100.000% Params, 3.764 GMac, 100.000% MACs, \n",
      "  (init_conv): ConvTranspose2d(0.0 M, 0.000% Params, 0.001 GMac, 0.016% MACs, 2, 3, kernel_size=(1, 1), stride=(1, 1))\n",
      "  (model): DenseNet(\n",
      "    6.968 M, 100.000% Params, 3.764 GMac, 99.984% MACs, \n",
      "    (features): Sequential(\n",
      "      6.954 M, 99.794% Params, 3.764 GMac, 99.984% MACs, \n",
      "      (conv0): Conv2d(0.009 M, 0.135% Params, 0.154 GMac, 4.095% MACs, 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "      (norm0): BatchNorm2d(0.0 M, 0.002% Params, 0.002 GMac, 0.056% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu0): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.028% MACs, inplace=True)\n",
      "      (pool0): MaxPool2d(0.0 M, 0.000% Params, 0.001 GMac, 0.028% MACs, kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "      (denseblock1): _DenseBlock(\n",
      "        0.335 M, 4.808% Params, 1.379 GMac, 36.634% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.045 M, 0.652% Params, 0.187 GMac, 4.965% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.002% Params, 0.001 GMac, 0.014% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.008 M, 0.118% Params, 0.034 GMac, 0.891% MACs, 64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.05 M, 0.712% Params, 0.204 GMac, 5.421% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.003% Params, 0.001 GMac, 0.021% MACs, 96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.012 M, 0.176% Params, 0.05 GMac, 1.337% MACs, 96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.054 M, 0.772% Params, 0.221 GMac, 5.878% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.016 M, 0.235% Params, 0.067 GMac, 1.783% MACs, 128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.058 M, 0.831% Params, 0.238 GMac, 6.334% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.005% Params, 0.001 GMac, 0.035% MACs, 160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.017% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.02 M, 0.294% Params, 0.084 GMac, 2.228% MACs, 160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.062 M, 0.891% Params, 0.256 GMac, 6.790% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.002 GMac, 0.042% MACs, 192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.021% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.025 M, 0.353% Params, 0.101 GMac, 2.674% MACs, 192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.066 M, 0.951% Params, 0.273 GMac, 7.246% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.002 GMac, 0.049% MACs, 224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.024% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.029 M, 0.411% Params, 0.117 GMac, 3.120% MACs, 224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 4.011% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition1): _Transition(\n",
      "        0.033 M, 0.478% Params, 0.138 GMac, 3.663% MACs, \n",
      "        (norm): BatchNorm2d(0.001 M, 0.007% Params, 0.002 GMac, 0.056% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.028% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.033 M, 0.470% Params, 0.134 GMac, 3.566% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock2): _DenseBlock(\n",
      "        0.92 M, 13.198% Params, 0.947 GMac, 25.159% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.054 M, 0.772% Params, 0.055 GMac, 1.469% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.016 M, 0.235% Params, 0.017 GMac, 0.446% MACs, 128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.058 M, 0.831% Params, 0.06 GMac, 1.583% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.005% Params, 0.0 GMac, 0.009% MACs, 160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.02 M, 0.294% Params, 0.021 GMac, 0.557% MACs, 160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.062 M, 0.891% Params, 0.064 GMac, 1.697% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.0 GMac, 0.010% MACs, 192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.025 M, 0.353% Params, 0.025 GMac, 0.669% MACs, 192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.066 M, 0.951% Params, 0.068 GMac, 1.811% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.0 GMac, 0.012% MACs, 224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.029 M, 0.411% Params, 0.029 GMac, 0.780% MACs, 224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.07 M, 1.010% Params, 0.072 GMac, 1.926% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.007% Params, 0.001 GMac, 0.014% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.033 M, 0.470% Params, 0.034 GMac, 0.891% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.075 M, 1.070% Params, 0.077 GMac, 2.040% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.008% Params, 0.001 GMac, 0.016% MACs, 288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.008% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.079 M, 1.130% Params, 0.081 GMac, 2.154% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.009% Params, 0.001 GMac, 0.017% MACs, 320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.009% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.041 M, 0.588% Params, 0.042 GMac, 1.114% MACs, 320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.083 M, 1.189% Params, 0.085 GMac, 2.268% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.010% Params, 0.001 GMac, 0.019% MACs, 352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.045 M, 0.647% Params, 0.046 GMac, 1.226% MACs, 352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.087 M, 1.249% Params, 0.09 GMac, 2.382% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.011% Params, 0.001 GMac, 0.021% MACs, 384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.049 M, 0.705% Params, 0.05 GMac, 1.337% MACs, 384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.091 M, 1.309% Params, 0.094 GMac, 2.496% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.012% Params, 0.001 GMac, 0.023% MACs, 416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.011% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.053 M, 0.764% Params, 0.055 GMac, 1.448% MACs, 416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.095 M, 1.368% Params, 0.098 GMac, 2.610% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.013% Params, 0.001 GMac, 0.024% MACs, 448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.012% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.057 M, 0.823% Params, 0.059 GMac, 1.560% MACs, 448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.1 M, 1.428% Params, 0.103 GMac, 2.724% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.014% Params, 0.001 GMac, 0.026% MACs, 480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.013% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.061 M, 0.882% Params, 0.063 GMac, 1.671% MACs, 480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition2): _Transition(\n",
      "        0.132 M, 1.896% Params, 0.136 GMac, 3.614% MACs, \n",
      "        (norm): BatchNorm2d(0.001 M, 0.015% Params, 0.001 GMac, 0.028% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.014% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.131 M, 1.881% Params, 0.134 GMac, 3.566% MACs, 512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock3): _DenseBlock(\n",
      "        2.838 M, 40.724% Params, 0.731 GMac, 19.421% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.07 M, 1.010% Params, 0.018 GMac, 0.481% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.007% Params, 0.0 GMac, 0.003% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.033 M, 0.470% Params, 0.008 GMac, 0.223% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.075 M, 1.070% Params, 0.019 GMac, 0.510% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.008% Params, 0.0 GMac, 0.004% MACs, 288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.079 M, 1.130% Params, 0.02 GMac, 0.538% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.009% Params, 0.0 GMac, 0.004% MACs, 320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.041 M, 0.588% Params, 0.01 GMac, 0.279% MACs, 320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.083 M, 1.189% Params, 0.021 GMac, 0.567% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.010% Params, 0.0 GMac, 0.005% MACs, 352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.045 M, 0.647% Params, 0.012 GMac, 0.306% MACs, 352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.087 M, 1.249% Params, 0.022 GMac, 0.595% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.011% Params, 0.0 GMac, 0.005% MACs, 384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.049 M, 0.705% Params, 0.013 GMac, 0.334% MACs, 384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.091 M, 1.309% Params, 0.023 GMac, 0.624% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.012% Params, 0.0 GMac, 0.006% MACs, 416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.053 M, 0.764% Params, 0.014 GMac, 0.362% MACs, 416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.095 M, 1.368% Params, 0.025 GMac, 0.652% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.013% Params, 0.0 GMac, 0.006% MACs, 448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.057 M, 0.823% Params, 0.015 GMac, 0.390% MACs, 448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.1 M, 1.428% Params, 0.026 GMac, 0.681% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.014% Params, 0.0 GMac, 0.007% MACs, 480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.061 M, 0.882% Params, 0.016 GMac, 0.418% MACs, 480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.104 M, 1.488% Params, 0.027 GMac, 0.709% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.015% Params, 0.0 GMac, 0.007% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.066 M, 0.940% Params, 0.017 GMac, 0.446% MACs, 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.108 M, 1.548% Params, 0.028 GMac, 0.738% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.016% Params, 0.0 GMac, 0.007% MACs, 544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.07 M, 0.999% Params, 0.018 GMac, 0.474% MACs, 544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.112 M, 1.607% Params, 0.029 GMac, 0.766% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.0 GMac, 0.008% MACs, 576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.074 M, 1.058% Params, 0.019 GMac, 0.501% MACs, 576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.116 M, 1.667% Params, 0.03 GMac, 0.795% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.0 GMac, 0.008% MACs, 608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.078 M, 1.117% Params, 0.02 GMac, 0.529% MACs, 608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer13): _DenseLayer(\n",
      "          0.12 M, 1.727% Params, 0.031 GMac, 0.823% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.018% Params, 0.0 GMac, 0.009% MACs, 640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.082 M, 1.176% Params, 0.021 GMac, 0.557% MACs, 640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer14): _DenseLayer(\n",
      "          0.124 M, 1.786% Params, 0.032 GMac, 0.852% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.019% Params, 0.0 GMac, 0.009% MACs, 672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.086 M, 1.234% Params, 0.022 GMac, 0.585% MACs, 672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer15): _DenseLayer(\n",
      "          0.129 M, 1.846% Params, 0.033 GMac, 0.880% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.020% Params, 0.0 GMac, 0.010% MACs, 704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.09 M, 1.293% Params, 0.023 GMac, 0.613% MACs, 704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer16): _DenseLayer(\n",
      "          0.133 M, 1.906% Params, 0.034 GMac, 0.909% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.021% Params, 0.0 GMac, 0.010% MACs, 736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.094 M, 1.352% Params, 0.024 GMac, 0.641% MACs, 736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer17): _DenseLayer(\n",
      "          0.137 M, 1.965% Params, 0.035 GMac, 0.938% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.022% Params, 0.0 GMac, 0.010% MACs, 768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.098 M, 1.411% Params, 0.025 GMac, 0.669% MACs, 768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer18): _DenseLayer(\n",
      "          0.141 M, 2.025% Params, 0.036 GMac, 0.966% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.023% Params, 0.0 GMac, 0.011% MACs, 800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.102 M, 1.470% Params, 0.026 GMac, 0.696% MACs, 800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer19): _DenseLayer(\n",
      "          0.145 M, 2.085% Params, 0.037 GMac, 0.995% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.024% Params, 0.0 GMac, 0.011% MACs, 832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.106 M, 1.528% Params, 0.027 GMac, 0.724% MACs, 832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer20): _DenseLayer(\n",
      "          0.149 M, 2.145% Params, 0.039 GMac, 1.023% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.025% Params, 0.0 GMac, 0.012% MACs, 864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.111 M, 1.587% Params, 0.028 GMac, 0.752% MACs, 864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer21): _DenseLayer(\n",
      "          0.154 M, 2.204% Params, 0.04 GMac, 1.052% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.026% Params, 0.0 GMac, 0.012% MACs, 896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.115 M, 1.646% Params, 0.029 GMac, 0.780% MACs, 896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer22): _DenseLayer(\n",
      "          0.158 M, 2.264% Params, 0.041 GMac, 1.080% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.027% Params, 0.0 GMac, 0.013% MACs, 928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.119 M, 1.705% Params, 0.03 GMac, 0.808% MACs, 928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer23): _DenseLayer(\n",
      "          0.162 M, 2.324% Params, 0.042 GMac, 1.109% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.0 GMac, 0.013% MACs, 960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.123 M, 1.763% Params, 0.031 GMac, 0.836% MACs, 960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer24): _DenseLayer(\n",
      "          0.166 M, 2.383% Params, 0.043 GMac, 1.137% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.001 GMac, 0.013% MACs, 992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.127 M, 1.822% Params, 0.033 GMac, 0.864% MACs, 992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.009 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition3): _Transition(\n",
      "        0.526 M, 7.553% Params, 0.135 GMac, 3.590% MACs, \n",
      "        (norm): BatchNorm2d(0.002 M, 0.029% Params, 0.001 GMac, 0.014% MACs, 1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.007% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.524 M, 7.524% Params, 0.134 GMac, 3.566% MACs, 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.003% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock4): _DenseBlock(\n",
      "        2.158 M, 30.970% Params, 0.139 GMac, 3.693% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.104 M, 1.488% Params, 0.007 GMac, 0.177% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.015% Params, 0.0 GMac, 0.002% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.066 M, 0.940% Params, 0.004 GMac, 0.111% MACs, 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.108 M, 1.548% Params, 0.007 GMac, 0.184% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.016% Params, 0.0 GMac, 0.002% MACs, 544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.07 M, 0.999% Params, 0.004 GMac, 0.118% MACs, 544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.112 M, 1.607% Params, 0.007 GMac, 0.192% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.0 GMac, 0.002% MACs, 576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.074 M, 1.058% Params, 0.005 GMac, 0.125% MACs, 576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.116 M, 1.667% Params, 0.007 GMac, 0.199% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.0 GMac, 0.002% MACs, 608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.078 M, 1.117% Params, 0.005 GMac, 0.132% MACs, 608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.12 M, 1.727% Params, 0.008 GMac, 0.206% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.018% Params, 0.0 GMac, 0.002% MACs, 640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.082 M, 1.176% Params, 0.005 GMac, 0.139% MACs, 640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.124 M, 1.786% Params, 0.008 GMac, 0.213% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.019% Params, 0.0 GMac, 0.002% MACs, 672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.086 M, 1.234% Params, 0.006 GMac, 0.146% MACs, 672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.129 M, 1.846% Params, 0.008 GMac, 0.220% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.020% Params, 0.0 GMac, 0.002% MACs, 704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.09 M, 1.293% Params, 0.006 GMac, 0.153% MACs, 704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.133 M, 1.906% Params, 0.009 GMac, 0.227% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.021% Params, 0.0 GMac, 0.003% MACs, 736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.094 M, 1.352% Params, 0.006 GMac, 0.160% MACs, 736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.137 M, 1.965% Params, 0.009 GMac, 0.234% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.022% Params, 0.0 GMac, 0.003% MACs, 768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.098 M, 1.411% Params, 0.006 GMac, 0.167% MACs, 768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.141 M, 2.025% Params, 0.009 GMac, 0.242% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.023% Params, 0.0 GMac, 0.003% MACs, 800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.102 M, 1.470% Params, 0.007 GMac, 0.174% MACs, 800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.145 M, 2.085% Params, 0.009 GMac, 0.249% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.024% Params, 0.0 GMac, 0.003% MACs, 832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.106 M, 1.528% Params, 0.007 GMac, 0.181% MACs, 832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.149 M, 2.145% Params, 0.01 GMac, 0.256% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.025% Params, 0.0 GMac, 0.003% MACs, 864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.111 M, 1.587% Params, 0.007 GMac, 0.188% MACs, 864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer13): _DenseLayer(\n",
      "          0.154 M, 2.204% Params, 0.01 GMac, 0.263% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.026% Params, 0.0 GMac, 0.003% MACs, 896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.115 M, 1.646% Params, 0.007 GMac, 0.195% MACs, 896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer14): _DenseLayer(\n",
      "          0.158 M, 2.264% Params, 0.01 GMac, 0.270% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.027% Params, 0.0 GMac, 0.003% MACs, 928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.119 M, 1.705% Params, 0.008 GMac, 0.202% MACs, 928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer15): _DenseLayer(\n",
      "          0.162 M, 2.324% Params, 0.01 GMac, 0.277% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.0 GMac, 0.003% MACs, 960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.123 M, 1.763% Params, 0.008 GMac, 0.209% MACs, 960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer16): _DenseLayer(\n",
      "          0.166 M, 2.383% Params, 0.011 GMac, 0.284% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.0 GMac, 0.003% MACs, 992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.127 M, 1.822% Params, 0.008 GMac, 0.216% MACs, 992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.002 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (norm5): BatchNorm2d(0.002 M, 0.029% Params, 0.0 GMac, 0.003% MACs, 1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "    (classifier): Sequential(\n",
      "      0.014 M, 0.206% Params, 0.0 GMac, 0.000% MACs, \n",
      "      (0): Linear(0.014 M, 0.206% Params, 0.0 GMac, 0.000% MACs, in_features=1024, out_features=14, bias=True)\n",
      "      (1): Sigmoid(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, )\n",
      "    )\n",
      "  )\n",
      ")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: module _DenseLayer is treated as a zero-op.\n",
      "Warning: module _DenseBlock is treated as a zero-op.\n",
      "Warning: module _Transition is treated as a zero-op.\n",
      "Warning: module Sigmoid is treated as a zero-op.\n",
      "Warning: module DenseNet is treated as a zero-op.\n",
      "Warning: module Densenet121 is treated as a zero-op.\n",
      "Densenet121(\n",
      "  6.968 M, 100.000% Params, 60.219 GMac, 100.000% MACs, \n",
      "  (init_conv): ConvTranspose2d(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, 2, 3, kernel_size=(1, 1), stride=(1, 1))\n",
      "  (model): DenseNet(\n",
      "    6.968 M, 100.000% Params, 60.219 GMac, 100.000% MACs, \n",
      "    (features): Sequential(\n",
      "      6.954 M, 99.794% Params, 60.219 GMac, 100.000% MACs, \n",
      "      (conv0): Conv2d(0.009 M, 0.135% Params, 2.466 GMac, 4.095% MACs, 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "      (norm0): BatchNorm2d(0.0 M, 0.002% Params, 0.034 GMac, 0.056% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu0): ReLU(0.0 M, 0.000% Params, 0.017 GMac, 0.028% MACs, inplace=True)\n",
      "      (pool0): MaxPool2d(0.0 M, 0.000% Params, 0.017 GMac, 0.028% MACs, kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "      (denseblock1): _DenseBlock(\n",
      "        0.335 M, 4.808% Params, 22.064 GMac, 36.640% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.045 M, 0.652% Params, 2.991 GMac, 4.966% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.002% Params, 0.008 GMac, 0.014% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.008 M, 0.118% Params, 0.537 GMac, 0.892% MACs, 64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.05 M, 0.712% Params, 3.265 GMac, 5.422% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.003% Params, 0.013 GMac, 0.021% MACs, 96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.006 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.012 M, 0.176% Params, 0.805 GMac, 1.337% MACs, 96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.054 M, 0.772% Params, 3.54 GMac, 5.878% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.016 M, 0.235% Params, 1.074 GMac, 1.783% MACs, 128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.058 M, 0.831% Params, 3.815 GMac, 6.335% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.005% Params, 0.021 GMac, 0.035% MACs, 160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.01 GMac, 0.017% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.02 M, 0.294% Params, 1.342 GMac, 2.229% MACs, 160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.062 M, 0.891% Params, 4.089 GMac, 6.791% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.025 GMac, 0.042% MACs, 192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.013 GMac, 0.021% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.025 M, 0.353% Params, 1.611 GMac, 2.675% MACs, 192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.066 M, 0.951% Params, 4.364 GMac, 7.247% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.029 GMac, 0.049% MACs, 224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.015 GMac, 0.024% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.029 M, 0.411% Params, 1.879 GMac, 3.120% MACs, 224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.017 GMac, 0.028% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 2.416 GMac, 4.012% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition1): _Transition(\n",
      "        0.033 M, 0.478% Params, 2.206 GMac, 3.664% MACs, \n",
      "        (norm): BatchNorm2d(0.001 M, 0.007% Params, 0.034 GMac, 0.056% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.017 GMac, 0.028% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.033 M, 0.470% Params, 2.147 GMac, 3.566% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock2): _DenseBlock(\n",
      "        0.92 M, 13.198% Params, 15.153 GMac, 25.163% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.054 M, 0.772% Params, 0.885 GMac, 1.470% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.016 M, 0.235% Params, 0.268 GMac, 0.446% MACs, 128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.058 M, 0.831% Params, 0.954 GMac, 1.584% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.005% Params, 0.005 GMac, 0.009% MACs, 160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.02 M, 0.294% Params, 0.336 GMac, 0.557% MACs, 160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.062 M, 0.891% Params, 1.022 GMac, 1.698% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.006 GMac, 0.010% MACs, 192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.025 M, 0.353% Params, 0.403 GMac, 0.669% MACs, 192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.066 M, 0.951% Params, 1.091 GMac, 1.812% MACs, \n",
      "          (norm1): BatchNorm2d(0.0 M, 0.006% Params, 0.007 GMac, 0.012% MACs, 224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.029 M, 0.411% Params, 0.47 GMac, 0.780% MACs, 224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.07 M, 1.010% Params, 1.16 GMac, 1.926% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.007% Params, 0.008 GMac, 0.014% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.033 M, 0.470% Params, 0.537 GMac, 0.892% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.075 M, 1.070% Params, 1.228 GMac, 2.040% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.008% Params, 0.009 GMac, 0.016% MACs, 288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.005 GMac, 0.008% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.079 M, 1.130% Params, 1.297 GMac, 2.154% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.009% Params, 0.01 GMac, 0.017% MACs, 320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.005 GMac, 0.009% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.041 M, 0.588% Params, 0.671 GMac, 1.114% MACs, 320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.083 M, 1.189% Params, 1.366 GMac, 2.268% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.010% Params, 0.012 GMac, 0.019% MACs, 352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.006 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.045 M, 0.647% Params, 0.738 GMac, 1.226% MACs, 352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.087 M, 1.249% Params, 1.434 GMac, 2.382% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.011% Params, 0.013 GMac, 0.021% MACs, 384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.006 GMac, 0.010% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.049 M, 0.705% Params, 0.805 GMac, 1.337% MACs, 384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.091 M, 1.309% Params, 1.503 GMac, 2.496% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.012% Params, 0.014 GMac, 0.023% MACs, 416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.007 GMac, 0.011% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.053 M, 0.764% Params, 0.872 GMac, 1.449% MACs, 416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.095 M, 1.368% Params, 1.572 GMac, 2.610% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.013% Params, 0.015 GMac, 0.024% MACs, 448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.007 GMac, 0.012% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.057 M, 0.823% Params, 0.94 GMac, 1.560% MACs, 448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.1 M, 1.428% Params, 1.64 GMac, 2.724% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.014% Params, 0.016 GMac, 0.026% MACs, 480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.013% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.061 M, 0.882% Params, 1.007 GMac, 1.672% MACs, 480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.004 GMac, 0.007% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.604 GMac, 1.003% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition2): _Transition(\n",
      "        0.132 M, 1.896% Params, 2.177 GMac, 3.615% MACs, \n",
      "        (norm): BatchNorm2d(0.001 M, 0.015% Params, 0.017 GMac, 0.028% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.008 GMac, 0.014% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.131 M, 1.881% Params, 2.147 GMac, 3.566% MACs, 512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock3): _DenseBlock(\n",
      "        2.838 M, 40.724% Params, 11.697 GMac, 19.425% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.07 M, 1.010% Params, 0.29 GMac, 0.481% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.007% Params, 0.002 GMac, 0.003% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.033 M, 0.470% Params, 0.134 GMac, 0.223% MACs, 256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.075 M, 1.070% Params, 0.307 GMac, 0.510% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.008% Params, 0.002 GMac, 0.004% MACs, 288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.079 M, 1.130% Params, 0.324 GMac, 0.538% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.009% Params, 0.003 GMac, 0.004% MACs, 320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.041 M, 0.588% Params, 0.168 GMac, 0.279% MACs, 320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.083 M, 1.189% Params, 0.341 GMac, 0.567% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.010% Params, 0.003 GMac, 0.005% MACs, 352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.045 M, 0.647% Params, 0.185 GMac, 0.306% MACs, 352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.087 M, 1.249% Params, 0.359 GMac, 0.596% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.011% Params, 0.003 GMac, 0.005% MACs, 384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.049 M, 0.705% Params, 0.201 GMac, 0.334% MACs, 384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.091 M, 1.309% Params, 0.376 GMac, 0.624% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.012% Params, 0.003 GMac, 0.006% MACs, 416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.053 M, 0.764% Params, 0.218 GMac, 0.362% MACs, 416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.095 M, 1.368% Params, 0.393 GMac, 0.653% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.013% Params, 0.004 GMac, 0.006% MACs, 448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.057 M, 0.823% Params, 0.235 GMac, 0.390% MACs, 448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.1 M, 1.428% Params, 0.41 GMac, 0.681% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.014% Params, 0.004 GMac, 0.007% MACs, 480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.061 M, 0.882% Params, 0.252 GMac, 0.418% MACs, 480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.104 M, 1.488% Params, 0.427 GMac, 0.710% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.015% Params, 0.004 GMac, 0.007% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.066 M, 0.940% Params, 0.268 GMac, 0.446% MACs, 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.108 M, 1.548% Params, 0.444 GMac, 0.738% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.016% Params, 0.004 GMac, 0.007% MACs, 544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.07 M, 0.999% Params, 0.285 GMac, 0.474% MACs, 544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.112 M, 1.607% Params, 0.462 GMac, 0.767% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.005 GMac, 0.008% MACs, 576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.074 M, 1.058% Params, 0.302 GMac, 0.501% MACs, 576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.116 M, 1.667% Params, 0.479 GMac, 0.795% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.005 GMac, 0.008% MACs, 608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.002 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.078 M, 1.117% Params, 0.319 GMac, 0.529% MACs, 608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer13): _DenseLayer(\n",
      "          0.12 M, 1.727% Params, 0.496 GMac, 0.824% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.018% Params, 0.005 GMac, 0.009% MACs, 640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.004% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.082 M, 1.176% Params, 0.336 GMac, 0.557% MACs, 640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer14): _DenseLayer(\n",
      "          0.124 M, 1.786% Params, 0.513 GMac, 0.852% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.019% Params, 0.006 GMac, 0.009% MACs, 672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.086 M, 1.234% Params, 0.352 GMac, 0.585% MACs, 672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer15): _DenseLayer(\n",
      "          0.129 M, 1.846% Params, 0.53 GMac, 0.881% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.020% Params, 0.006 GMac, 0.010% MACs, 704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.09 M, 1.293% Params, 0.369 GMac, 0.613% MACs, 704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer16): _DenseLayer(\n",
      "          0.133 M, 1.906% Params, 0.547 GMac, 0.909% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.021% Params, 0.006 GMac, 0.010% MACs, 736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.094 M, 1.352% Params, 0.386 GMac, 0.641% MACs, 736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer17): _DenseLayer(\n",
      "          0.137 M, 1.965% Params, 0.565 GMac, 0.938% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.022% Params, 0.006 GMac, 0.010% MACs, 768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.098 M, 1.411% Params, 0.403 GMac, 0.669% MACs, 768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer18): _DenseLayer(\n",
      "          0.141 M, 2.025% Params, 0.582 GMac, 0.966% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.023% Params, 0.007 GMac, 0.011% MACs, 800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.005% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.102 M, 1.470% Params, 0.419 GMac, 0.697% MACs, 800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer19): _DenseLayer(\n",
      "          0.145 M, 2.085% Params, 0.599 GMac, 0.995% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.024% Params, 0.007 GMac, 0.011% MACs, 832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.003 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.106 M, 1.528% Params, 0.436 GMac, 0.724% MACs, 832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer20): _DenseLayer(\n",
      "          0.149 M, 2.145% Params, 0.616 GMac, 1.023% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.025% Params, 0.007 GMac, 0.012% MACs, 864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.111 M, 1.587% Params, 0.453 GMac, 0.752% MACs, 864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer21): _DenseLayer(\n",
      "          0.154 M, 2.204% Params, 0.633 GMac, 1.052% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.026% Params, 0.007 GMac, 0.012% MACs, 896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.115 M, 1.646% Params, 0.47 GMac, 0.780% MACs, 896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer22): _DenseLayer(\n",
      "          0.158 M, 2.264% Params, 0.651 GMac, 1.080% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.027% Params, 0.008 GMac, 0.013% MACs, 928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.006% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.119 M, 1.705% Params, 0.487 GMac, 0.808% MACs, 928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer23): _DenseLayer(\n",
      "          0.162 M, 2.324% Params, 0.668 GMac, 1.109% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.008 GMac, 0.013% MACs, 960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.123 M, 1.763% Params, 0.503 GMac, 0.836% MACs, 960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer24): _DenseLayer(\n",
      "          0.166 M, 2.383% Params, 0.685 GMac, 1.137% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.008 GMac, 0.013% MACs, 992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.127 M, 1.822% Params, 0.52 GMac, 0.864% MACs, 992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.001 GMac, 0.002% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.151 GMac, 0.251% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (transition3): _Transition(\n",
      "        0.526 M, 7.553% Params, 2.162 GMac, 3.590% MACs, \n",
      "        (norm): BatchNorm2d(0.002 M, 0.029% Params, 0.008 GMac, 0.014% MACs, 1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(0.0 M, 0.000% Params, 0.004 GMac, 0.007% MACs, inplace=True)\n",
      "        (conv): Conv2d(0.524 M, 7.524% Params, 2.147 GMac, 3.566% MACs, 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (pool): AvgPool2d(0.0 M, 0.000% Params, 0.002 GMac, 0.003% MACs, kernel_size=2, stride=2, padding=0)\n",
      "      )\n",
      "      (denseblock4): _DenseBlock(\n",
      "        2.158 M, 30.970% Params, 2.224 GMac, 3.694% MACs, \n",
      "        (denselayer1): _DenseLayer(\n",
      "          0.104 M, 1.488% Params, 0.107 GMac, 0.177% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.015% Params, 0.001 GMac, 0.002% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.066 M, 0.940% Params, 0.067 GMac, 0.111% MACs, 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer2): _DenseLayer(\n",
      "          0.108 M, 1.548% Params, 0.111 GMac, 0.185% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.016% Params, 0.001 GMac, 0.002% MACs, 544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.07 M, 0.999% Params, 0.071 GMac, 0.118% MACs, 544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer3): _DenseLayer(\n",
      "          0.112 M, 1.607% Params, 0.115 GMac, 0.192% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.001 GMac, 0.002% MACs, 576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.074 M, 1.058% Params, 0.075 GMac, 0.125% MACs, 576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer4): _DenseLayer(\n",
      "          0.116 M, 1.667% Params, 0.12 GMac, 0.199% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.017% Params, 0.001 GMac, 0.002% MACs, 608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.078 M, 1.117% Params, 0.08 GMac, 0.132% MACs, 608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer5): _DenseLayer(\n",
      "          0.12 M, 1.727% Params, 0.124 GMac, 0.206% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.018% Params, 0.001 GMac, 0.002% MACs, 640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.082 M, 1.176% Params, 0.084 GMac, 0.139% MACs, 640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer6): _DenseLayer(\n",
      "          0.124 M, 1.786% Params, 0.128 GMac, 0.213% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.019% Params, 0.001 GMac, 0.002% MACs, 672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.086 M, 1.234% Params, 0.088 GMac, 0.146% MACs, 672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer7): _DenseLayer(\n",
      "          0.129 M, 1.846% Params, 0.133 GMac, 0.220% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.020% Params, 0.001 GMac, 0.002% MACs, 704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.09 M, 1.293% Params, 0.092 GMac, 0.153% MACs, 704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer8): _DenseLayer(\n",
      "          0.133 M, 1.906% Params, 0.137 GMac, 0.227% MACs, \n",
      "          (norm1): BatchNorm2d(0.001 M, 0.021% Params, 0.002 GMac, 0.003% MACs, 736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.094 M, 1.352% Params, 0.096 GMac, 0.160% MACs, 736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer9): _DenseLayer(\n",
      "          0.137 M, 1.965% Params, 0.141 GMac, 0.234% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.022% Params, 0.002 GMac, 0.003% MACs, 768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.098 M, 1.411% Params, 0.101 GMac, 0.167% MACs, 768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer10): _DenseLayer(\n",
      "          0.141 M, 2.025% Params, 0.145 GMac, 0.242% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.023% Params, 0.002 GMac, 0.003% MACs, 800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.102 M, 1.470% Params, 0.105 GMac, 0.174% MACs, 800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer11): _DenseLayer(\n",
      "          0.145 M, 2.085% Params, 0.15 GMac, 0.249% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.024% Params, 0.002 GMac, 0.003% MACs, 832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.106 M, 1.528% Params, 0.109 GMac, 0.181% MACs, 832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer12): _DenseLayer(\n",
      "          0.149 M, 2.145% Params, 0.154 GMac, 0.256% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.025% Params, 0.002 GMac, 0.003% MACs, 864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.001% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.111 M, 1.587% Params, 0.113 GMac, 0.188% MACs, 864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer13): _DenseLayer(\n",
      "          0.154 M, 2.204% Params, 0.158 GMac, 0.263% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.026% Params, 0.002 GMac, 0.003% MACs, 896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.115 M, 1.646% Params, 0.117 GMac, 0.195% MACs, 896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer14): _DenseLayer(\n",
      "          0.158 M, 2.264% Params, 0.163 GMac, 0.270% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.027% Params, 0.002 GMac, 0.003% MACs, 928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.119 M, 1.705% Params, 0.122 GMac, 0.202% MACs, 928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer15): _DenseLayer(\n",
      "          0.162 M, 2.324% Params, 0.167 GMac, 0.277% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.002 GMac, 0.003% MACs, 960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.123 M, 1.763% Params, 0.126 GMac, 0.209% MACs, 960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "        (denselayer16): _DenseLayer(\n",
      "          0.166 M, 2.383% Params, 0.171 GMac, 0.284% MACs, \n",
      "          (norm1): BatchNorm2d(0.002 M, 0.028% Params, 0.002 GMac, 0.003% MACs, 992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu1): ReLU(0.0 M, 0.000% Params, 0.001 GMac, 0.002% MACs, inplace=True)\n",
      "          (conv1): Conv2d(0.127 M, 1.822% Params, 0.13 GMac, 0.216% MACs, 992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (norm2): BatchNorm2d(0.0 M, 0.004% Params, 0.0 GMac, 0.000% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "          (relu2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, inplace=True)\n",
      "          (conv2): Conv2d(0.037 M, 0.529% Params, 0.038 GMac, 0.063% MACs, 128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        )\n",
      "      )\n",
      "      (norm5): BatchNorm2d(0.002 M, 0.029% Params, 0.002 GMac, 0.003% MACs, 1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "    (classifier): Sequential(\n",
      "      0.014 M, 0.206% Params, 0.0 GMac, 0.000% MACs, \n",
      "      (0): Linear(0.014 M, 0.206% Params, 0.0 GMac, 0.000% MACs, in_features=1024, out_features=14, bias=True)\n",
      "      (1): Sigmoid(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, )\n",
      "    )\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from ptflops import get_model_complexity_info\n",
    "from networks import Densenet121\n",
    "from utilities import ChestXrayHDF5, compute_AUCs, save_loss_AUROC_plots\n",
    "\n",
    "cuda = True if torch.cuda.is_available() else False\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "\n",
    "model_l = Densenet121(n_classes=14, input_type='latent')\n",
    "macs_l, params_l = get_model_complexity_info(model_l, (2, 256, 256), as_strings=True,\n",
    "                                             print_per_layer_stat=True, verbose=True)\n",
    "\n",
    "model_o = Densenet121(n_classes=14, input_type='orig')\n",
    "macs_o, params_o = get_model_complexity_info(model_o, (3, 1024, 1024), as_strings=True,\n",
    "                                             print_per_layer_stat=True, verbose=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.76 GMac 6.97 M\n",
      "60.22 GMac 6.97 M\n"
     ]
    }
   ],
   "source": [
    "print(macs_l,params_l)\n",
    "print(macs_o,params_o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
